[PATCH] <short summary of the patch>

TODO: Put a short summary on the line above and replace this paragraph
with a longer explanation of this change. Complete the meta-information
with other relevant fields (see below for details). To make it easier, the
information below has been extracted from the changelog. Adjust it or drop
it.

Gbp-Pq: Name Version_2_7_2pre27

diff --git a/cmpnew/gcl_cmpenv.lsp b/cmpnew/gcl_cmpenv.lsp
index 3816ef3654611f79dc93daea2a1fd51beb2df64f..6a4e822c80777c19b7232b5bbb798f01e88d842e 100644 (file)
--- a/cmpnew/gcl_cmpenv.lsp
+++ b/cmpnew/gcl_cmpenv.lsp
@@ -258,7 +258,12 @@
      (local-fun-fn fname)
      (get fname 'cmp-inline)
      (member (symbol-package fname)
-            (load-time-value (mapcar #'symbol-package (list 'c-t-tt (mdlsym "sin") (mdlsym "memmove"))))))))
+            (load-time-value
+             (remove-duplicates
+              (mapcar #'symbol-package
+                      (list 'c-t-tt
+                            (mdlsym "fabs");FOXME dladdr macos unreliable, need core mdl in raw images
+                            (mdlsym "sin") (mdlsym "memmove")))))))))
 
 ;; (defun inline-asserted (fname)
 ;;   (unless *compiler-push-events*

diff --git a/git.tag b/git.tag
index 82688e33e7d38cb7864c4913900b4d3f3a2369cf..e684561bdd80ef6942217a6796c0c3ef81e0485d 100644 (file)
--- a/git.tag
+++ b/git.tag
@@ -1 +1 @@
-"Version_2_7_2pre26"
+"Version_2_7_2pre27"

diff --git a/h/386-macosx.h b/h/386-macosx.h
index f00069f9a48ab2a35d56ff177c0e2db236832682..d977a3e57b243a620c63dd9165b50f172a210170 100644 (file)
--- a/h/386-macosx.h
+++ b/h/386-macosx.h
@@ -20,11 +20,6 @@
 #undef HAVE_AOUT
 #undef HAVE_ELF
 
-
-/* Alternatively, we could use the global variable vm_page_size.  */
-#define PAGEWIDTH 12
-
-
 #include <unistd.h> /* to get sbrk defined */
 
 
@@ -107,18 +102,17 @@ do {int c=0;                                                            \
 
 #define GET_FULL_PATH_SELF(a_)                              \
 do {                                                        \
-extern int _NSGetExecutablePath (char *, unsigned long *);  \
-unsigned long bufsize = 1024;                               \
-static char buf [1024];                                     \
-static char fub [1024];                                     \
-if (_NSGetExecutablePath (buf, &bufsize) != 0) {            \
+  uint32_t bufsize = 1024;                                 \
+  static char buf [1024];                                  \
+  static char fub [1024];                                  \
+  if (_NSGetExecutablePath (buf, &bufsize) != 0) {         \
     error ("_NSGetExecutablePath failed");                  \
-}                                                           \
-if (realpath (buf, fub) == 0) {                             \
+  }                                                        \
+  if (realpath (buf, fub) == 0) {                          \
     error ("realpath failed");                              \
-}                                                           \
-(a_) = fub;                                                 \
-} while (0)
+  }                                                        \
+  (a_) = fub;                                              \
+ } while (0)
 
 #ifdef _LP64
 #define C_GC_OFFSET 4
@@ -155,7 +149,7 @@ if (realpath (buf, fub) == 0) {                             \
                                     REG_LIST(8,MCF(__fpu_stmm0)),REG_LIST(16,MCF(__fpu_xmm0)));})
 
 
-#include <sys/param.h>/*PATH_MAX MAXPATHLEN*/
+#include <sys/param.h>
 #undef MIN
 #undef MAX
 

diff --git a/h/aarch64-macosx.h b/h/aarch64-macosx.h
index 9af4b51c0770773f54ff1bb874ff6be2e362833d..a110d19e04f59f46c1b01c3bbc4fb7b95572e5a2 100644 (file)
--- a/h/aarch64-macosx.h
+++ b/h/aarch64-macosx.h
@@ -20,11 +20,6 @@
 #undef HAVE_AOUT
 #undef HAVE_ELF
 
-
-/* Alternatively, we could use the global variable vm_page_size.  */
-/* #define PAGEWIDTH 12 */
-
-
 #include <unistd.h> /* to get sbrk defined */
 
 
@@ -107,17 +102,17 @@ do {int c=0;                                                            \
 
 #define GET_FULL_PATH_SELF(a_)                              \
 do {                                                        \
-uint32_t bufsize = 1024;                               \
-static char buf [1024];                                     \
-static char fub [1024];                                     \
-if (_NSGetExecutablePath (buf, &bufsize) != 0) {            \
+  uint32_t bufsize = 1024;                                 \
+  static char buf [1024];                                  \
+  static char fub [1024];                                  \
+  if (_NSGetExecutablePath (buf, &bufsize) != 0) {         \
     error ("_NSGetExecutablePath failed");                  \
-}                                                           \
-if (realpath (buf, fub) == 0) {                             \
+  }                                                        \
+  if (realpath (buf, fub) == 0) {                          \
     error ("realpath failed");                              \
-}                                                           \
-(a_) = fub;                                                 \
-} while (0)
+  }                                                        \
+  (a_) = fub;                                              \
+ } while (0)
 
 #define C_GC_OFFSET 4
 #include <mach-o/arm64/reloc.h>
@@ -141,7 +136,7 @@ if (realpath (buf, fub) == 0) {                             \
 
 #define FPE_INIT Cnil
 
-#include <sys/param.h>/*PATH_MAX MAXPATHLEN*/
+#include <sys/param.h>
 #undef MIN
 #undef MAX
 

diff --git a/h/mach64_i386_reloc.h b/h/mach64_i386_reloc.h
index a0f406b1b2c76421db0b02ab2e9a00c6b116dfc4..1397ddef24105302a2df450666df537fde372209 100644 (file)
--- a/h/mach64_i386_reloc.h
+++ b/h/mach64_i386_reloc.h
@@ -2,13 +2,13 @@
 
 #define GOT_RELOC(ri) ri->r_type==X86_64_RELOC_GOT_LOAD||ri->r_type==X86_64_RELOC_GOT
 
-
   case X86_64_RELOC_UNSIGNED:          // for absolute addresses
 
      if (ri->r_extern || !ri->r_pcrel) 
       store_val(q,~0L,ri->r_pcrel ? a-rel : a);
 
     break; 
+
   case X86_64_RELOC_GOT_LOAD:          // a MOVQ load of a GOT entry
   case X86_64_RELOC_GOT:               // a MOVQ load of a GOT entry
 
@@ -17,10 +17,11 @@
     a=(ul)got;
 
   case X86_64_RELOC_SIGNED:            // for signed 32-bit displacement
+  case X86_64_RELOC_SIGNED_1:           // adjustment in *q
+  case X86_64_RELOC_SIGNED_4:           // adjustment in *q
   case X86_64_RELOC_BRANCH:            // a CALL/JMP instruction with 32-bit displacement
 
      if (ri->r_extern || !ri->r_pcrel)            
-       store_val(q,MASK(32),(ri->r_pcrel ? a-((ul)q+4) : a)+(signed)(*q&MASK(32)));
+       add_vals(q,MASK(32),(ri->r_pcrel ? a-((ul)q+4) : a));
 
     break;
-

diff --git a/h/protoize.h b/h/protoize.h
index 77a6f7d9beb61f489ab0a842da399c56fe99b948..07ab0e3c25ad6dc7618f9625a609a87852610aeb 100644 (file)
--- a/h/protoize.h
+++ b/h/protoize.h
@@ -1673,6 +1673,5 @@ void stack_list(void);
 void *msbrk(intptr_t);
 int msbrk_init(void);
 int msbrk_end(void);
-
-object
-quick_call_function_vec(object,ufixnum,object *);
+object quick_call_function_vec(object,ufixnum,object *);
+int msbrk_initialized(void);

diff --git a/lsp/gcl_dl.lsp b/lsp/gcl_dl.lsp
index 6f6b35f44351bacb073909efc5a190badca19e89..c76937b97db56012852fb621d09cb20a49f5a7a0 100644 (file)
--- a/lsp/gcl_dl.lsp
+++ b/lsp/gcl_dl.lsp
@@ -3,27 +3,76 @@
 
 (export '(mdlsym mdl lib-name))
 
-(defun lib-name (p)
-  (if (or (string= p "") (string= p "libc") (string= p "libm")) "" 
-    (string-concatenate #+darwin "/usr/lib/system/" p #+darwin ".dylib" #+cygwin ".dll" #-(or darwin cygwin) ".so")));FIXME
+(defvar *lib-package-syms* nil);FIXME accelerator for do-symbols
+(defvar *dladdr-mods* nil)
+(defconstant +dl-suffix+ #+darwin ".dylib" #+cygwin ".dll" #-(or darwin cygwin) ".so")
+
+(defun esubseq (s &optional (b 0) (e (length s)) &aux (s (string s)));avoid mdl/memmove call in subseq
+  (make-vector 'character (- e b) nil nil s b nil nil))
+
+(defun name-lib (n)
+  (when (>= (string-match (load-time-value (compile-regexp "\([^/]*\)$")) n) 0)
+    (setq n (esubseq n (match-beginning 1) (match-end 1))))
+  (when (>= (string-match (load-time-value (compile-regexp "(\.(so|dylib|dll))$")) n) 0)
+    (setq n (esubseq n 0 (match-beginning 1))))
+  #+darwin(when (>= (string-match (load-time-value (compile-regexp "^libsystem")) n) 0)
+           (setq n "libSystem"))
+  n)
+
+(defun lib-name (p &aux (p (name-lib p)))
+  (if (member p '("" "libc" "libm") :test #'string=)
+      "" ; FIXME
+      (string-concatenate p +dl-suffix+)))
+
+(defun find-external-symbol (str p)
+  (multiple-value-bind (sym key) (find-symbol str p)
+    (when (eq key :external)
+      sym)))
+
+(defun fdlsym (str n pk &aux r sym)
+  (declare (dynamic-extent r))
+  (let* ((n (name-lib n))
+        (psym (find-symbol n pk)))
+    (mapc (lambda (x &aux (s (find-external-symbol str x)))
+           (when s
+             (when (if sym (<= (symbol-value s) (symbol-value sym)) t)
+               (setq sym s))))
+         (if psym
+             (push psym r)
+             (when (zerop (length n))
+               *lib-package-syms*)))
+    sym))
+
+(defun dladdr-mod (p n &aux (p (name-lib p))(n (name-lib n)))
+  (cond ((cdr (assoc p *dladdr-mods* :test 'string=)))
+       ((unless (string= p n) (plusp (length n)))
+        (cdar (push (cons p n) *dladdr-mods*)))
+       (p)))
+
+(defun reg-psym (psym)
+  (car (or (member psym *lib-package-syms*)
+          (push psym *lib-package-syms*))))
+
+(defun mdlsym (str &optional (n "")
+              &aux (n (lib-name n))
+                (pk (load-time-value (or (find-package "LIB") (make-package "LIB")))))
+  (or
+   (fdlsym str n pk);FIXME repeated dlsym unreliable on non-Linux
+   (let* ((k (dlopen n))
+         (ad (dlsym k str))
+         (p (or (dladdr ad t) ""));FIXME work around dladdr here, not posix
+         (p (dladdr-mod p n))
+         (psym (reg-psym (intern p pk)))
+         (npk (or (find-package psym) (make-package psym :use '(:cl))))
+         (sym (and (shadow str npk) (intern str npk))))
+     (export (list psym) pk)
+     (export sym npk)
+     (set psym k)(set sym ad)
+     sym)))
 
 (defun mdl (n p vad)
-  (let* ((sym (mdlsym n (lib-name p)))
+  (let* ((sym (mdlsym n p))
         (ad (symbol-value sym))
         (adp (aref %init vad)))
     (dladdr-set adp ad)
     (dllist-push %memory sym adp)))
-
-(defun mdlsym (str &optional (n "" np))
-  (let* ((pk (or (find-package "LIB") (make-package "LIB")))
-        (k  (if np (dlopen n) 0))
-        (ad (dlsym k str))
-        (p (or (dladdr ad t) ""));FIXME work around dladdr here, not posix
-        (psym (intern p pk))
-        (npk (or (find-package psym) (make-package psym :use '(:cl))))
-        (sym (and (shadow str npk) (intern str npk))))
-    (export (list psym) pk)
-    (export sym npk)
-    (set psym k)(set sym ad)
-    sym))
-

diff --git a/o/alloc.c b/o/alloc.c
index fe6715e5f6b94a1f03b39b51219f73eaa56aee6d..c38a329b1ef15fe8f37da87e913f945a9c2e578e 100644 (file)
--- a/o/alloc.c
+++ b/o/alloc.c
@@ -1700,19 +1700,14 @@ bool writable_malloc=0;
 static void *
 malloc_internal(size_t size) {
 
-  if (!gcl_alloc_initialized) {
+  if (!msbrk_initialized()) {
     static bool recursive_malloc;
     if (recursive_malloc)
       error("Bad malloc");
     recursive_malloc=1;
     gcl_init_alloc(&size);
     recursive_malloc=0;
-  } else
-    /*FIXME idempotent but required gcl_init_alloc functions in saved images*/
-#ifdef INITIALIZE_BRK
-    INITIALIZE_BRK;
-#endif
-
+  }
 
   CHECK_INTERRUPT;
   

diff --git a/o/cfun.c b/o/cfun.c
index 7826619b3526888881090df7cb92f81d5a878096..f6e3c725fcc04e054936959cf327405866b1522e 100644 (file)
--- a/o/cfun.c
+++ b/o/cfun.c
@@ -76,29 +76,16 @@ DEFUN("CFDL",object,fScfdl,SI,0,0,NONE,OO,OO,OO,OO,(void),"") {
     
 DEFUN("DLSYM",object,fSdlsym,SI,2,2,NONE,OI,OO,OO,OO,(fixnum h,object name),"") {
 
-  void *ad;
+  void *ad=0;
 
   dlerror();
   name=coerce_to_string(name);
   massert(snprintf(FN1,sizeof(FN1),"%-.*s",VLEN(name),name->st.st_self)>0);
-#ifndef __CYGWIN__
+
   ad=dlsym(h ? (void *)h : RTLD_DEFAULT,FN1);
-  ad=ad ? ad : dlsym(RTLD_DEFAULT,FN1);
-  ad=is_text_addr(ad) ? dlsym(RTLD_NEXT,FN1) : ad;
-#else
-  ad=0;
-  if (h) ad=dlsym((void *)h,FN1);
-  {
-    static void *n,*u,*c;
-    n=n ? n : dlopen("ntdll.dll",RTLD_LAZY|RTLD_GLOBAL);
-    u=u ? u : dlopen("ucrtbase.dll",RTLD_LAZY|RTLD_GLOBAL);
-    c=c ? c : dlopen("cygwin1.dll",RTLD_LAZY|RTLD_GLOBAL);
-    ad=ad ? ad : dlsym(n,FN1);
-    ad=ad ? ad : dlsym(u,FN1);
-    ad=ad ? ad : dlsym(c,FN1);
-    ad=ad ? ad : dlsym(RTLD_DEFAULT,FN1);
-  }
-#endif
+
+  ad=ad && is_text_addr(ad) ? dlsym(RTLD_NEXT,FN1) : ad;
+
   if (!ad) {
     char *er=dlerror();
     FEerror("dlsym lookup failure on ~s: ~s",2,name,make_simple_string(er ? er : ""));
@@ -141,12 +128,8 @@ DEFUN("DLOPEN",object,fSdlopen,SI,1,1,NONE,OO,OO,OO,OO,(object name),"") {
 
   dlerror();
   name=coerce_to_string(name);
-  if (!strncmp("libc.so",name->st.st_self,VLEN(name)) || !strncmp("libm.so",name->st.st_self,VLEN(name)))
-    v=dlopen(0,RTLD_LAZY|RTLD_GLOBAL);
-  else {
-    massert(snprintf(FN1,sizeof(FN1),"%-.*s",VLEN(name),name->st.st_self)>0);
-    v=dlopen(FN1,RTLD_LAZY|RTLD_GLOBAL);
-  }
+  massert(snprintf(FN1,sizeof(FN1),"%-.*s",VLEN(name),name->st.st_self)>=0);
+  v=dlopen(strlen(FN1) ? FN1 : 0,RTLD_LAZY|RTLD_GLOBAL);
   if ((err=dlerror()))
     FEerror("dlopen failure on ~s: ~s",2,name,make_simple_string(err));
 

diff --git a/o/gprof.c b/o/gprof.c
index a38bdd90185503bf6bebd8f2c5c35a789df518a1..ecf3736888583edfe2aea7384cea12e20d0aaa2e 100644 (file)
--- a/o/gprof.c
+++ b/o/gprof.c
@@ -6,7 +6,7 @@
 static unsigned long gprof_on;
 
 /*all but this stub to be written in the future provided*/
-#if defined(__APPLE__) && defined(__aarch64__)
+#if defined(__APPLE__)
 void
 _mcleanup(void) {
   return;

diff --git a/o/main.c b/o/main.c
index 3b14a455758795b5e350ea8ec18c1e1d729aa92c..cd1cef2870b1ffe13e9f70eb34dfac9580043019 100644 (file)
--- a/o/main.c
+++ b/o/main.c
@@ -434,6 +434,10 @@ next_shared_lib_map_no_malloc(void)  {
 static void *stack_map_base=(void *)-1;
 void *shared_lib_start=(void *)-1;
 
+#if defined(__APPLE__)
+unsigned long heap_vmsize=INITIAL_HEAP_VMSIZE;
+#endif
+
 static int
 set_real_maxpage(void *beg) {
 
@@ -445,11 +449,8 @@ set_real_maxpage(void *beg) {
 
   mp=ufmin(mp,get_phys_pages1(0,0));
 
-#if defined(__APPLE__) && defined(__aarch64__)
-  {
-    extern unsigned long heap_vmsize;
-    mp=ufmin(mp,heap_vmsize>>PAGEWIDTH);
-  }
+#if defined(__APPLE__)
+  mp=ufmin(mp,heap_vmsize>>PAGEWIDTH);
 #endif
 
   sz=ufmin(mem_bound,log_maxpage_bound);
@@ -722,7 +723,7 @@ DEFUN("KCL-SELF",object,fSkcl_self,SI,0,0,NONE,OO,OO,OO,OO,(void),"") {
 
 }
 
-#if defined(__APPLE__) && defined(__aarch64__)
+#if defined(__APPLE__)
 #include "disable_mac_aslr.h"
 #endif
 
@@ -737,7 +738,7 @@ main(int argc, char **argv, char **envp) {
   bds_top = bds_org-1;
   frs_top = frs_org-1;
 
-#if defined(__APPLE__) && defined(__aarch64__)
+#if defined(__APPLE__)
   disable_aslr(argc, argv, envp);
 #endif
 

diff --git a/o/msbrk.c b/o/msbrk.c
index f73f947b4a51b5e8a399947f8cf82a279461ea5a..c397e755ee22bbd09fbbaab808574b1561512e6c 100644 (file)
--- a/o/msbrk.c
+++ b/o/msbrk.c
@@ -6,6 +6,11 @@
 static void *m;
 static ufixnum sz,mps;
 
+int
+msbrk_initialized(void) {
+  return m!=NULL;
+}
+
 int
 msbrk_end(void) {
 
@@ -33,7 +38,6 @@ new_map(void *v,ufixnum s) {
   but not so large that the Mac linker ignores the segment designation
   and creates a __huge section under __DATA for this and other
   variables.  We enlarge this on unexec.*/
-unsigned long heap_vmsize=INITIAL_HEAP_VMSIZE;
 #define mstr(a) #a
 #define Mstr(a) mstr(a)
 asm (".zerofill __HEAP,__heap,__end," Mstr(INITIAL_HEAP_VMSIZE) "\n\t.globl __end");

diff --git a/o/regexp.c b/o/regexp.c
index fb64f4c5e90c8ec4780309795a56edeb7ffdd1cb..a82f52557f99905d59031583cf9eda44dd7e579b 100644 (file)
--- a/o/regexp.c
+++ b/o/regexp.c
@@ -230,8 +230,13 @@ int case_fold_search = 0;
  * Beware that the optimization-preparation code in here knows about some
  * of the structure of the compiled regexp.
  */
+
+static char *regend;           /* Non null terminated string end */
+#define GET_UCHAR(a_) ({char *_a=(a_);_a<regend ? *(unsigned char *)_a : 0;})
+
+
 static regexp *
-regcomp(char *exp,ufixnum *sz)
+regcomp(char *exp,ufixnum *sz,ufixnum length)
 {
        register regexp *r;
        register char *scan;
@@ -244,6 +249,7 @@ regcomp(char *exp,ufixnum *sz)
 
        /* First pass: determine size, legality. */
        regparse = exp;
+       regend=exp+length;
        regnpar = 1;
        regsize = 0L;
        regcode = &regdummy;
@@ -263,6 +269,7 @@ regcomp(char *exp,ufixnum *sz)
 
        /* Second pass: emit code. */
        regparse = exp;
+       regend=exp+length;
        regnpar = 1;
        regcode = r->program;
        regc(MAGIC);
@@ -356,7 +363,7 @@ reg(int paren, int *flagp)
        if (!(flags&HASWIDTH))
                *flagp &= ~HASWIDTH;
        *flagp |= flags&SPSTART;
-       while (*regparse == '|') {
+       while (GET_UCHAR(regparse) == '|') {
                regparse++;
                br = regbranch(&flags);
                if (br == NULL)
@@ -376,10 +383,10 @@ reg(int paren, int *flagp)
                regoptail(br, ender);
 
        /* Check for proper termination. */
-       if (paren && *regparse++ != ')') {
+       if (paren && GET_UCHAR(regparse++) != ')') {
                FAIL("unmatched ()");
-       } else if (!paren && *regparse != '\0') {
-               if (*regparse == ')') {
+       } else if (!paren && GET_UCHAR(regparse) != '\0') {
+         if (GET_UCHAR(regparse) == ')') {
                        FAIL("unmatched ()");
                } else
                        FAIL("junk on end");    /* "Can't happen". */
@@ -406,7 +413,7 @@ regbranch(int *flagp)
 
        ret = regnode(BRANCH);
        chain = NULL;
-       while (*regparse != '\0' && *regparse != '|' && *regparse != ')') {
+       while (GET_UCHAR(regparse) != '\0' && GET_UCHAR(regparse) != '|' && GET_UCHAR(regparse) != ')') {
                latest = regpiece(&flags);
                if (latest == NULL)
                        return(NULL);
@@ -444,7 +451,7 @@ regpiece(int *flagp)
        if (ret == NULL)
                return(NULL);
 
-       op = *regparse;
+       op = GET_UCHAR(regparse);
        if (!ISMULT(op)) {
                *flagp = flags;
                return(ret);
@@ -481,7 +488,7 @@ regpiece(int *flagp)
                regoptail(ret, next);
        }
        regparse++;
-       if (ISMULT(*regparse))
+       if (ISMULT(GET_UCHAR(regparse)))
                FAIL("nested *?+");
 
        return(ret);
@@ -503,7 +510,7 @@ regatom(int *flagp)
 
        *flagp = WORST;         /* Tentatively. */
 
-       switch (*regparse++) {
+       switch (GET_UCHAR(regparse++)) {
        case '^':
                ret = regnode(BOL);
                break;
@@ -524,19 +531,19 @@ regatom(int *flagp)
                        register int classend;
                        ret = regnode(ANYOF);
 
-                       if (*regparse == '^') { /* Complement of range. */
+                       if (GET_UCHAR(regparse) == '^') {       /* Complement of range. */
                                matches = 0;
                                regparse++;}
-                       if (*regparse == ']' || *regparse == '-')
-                               REGC(*regparse++);
-                       while (*regparse != '\0' && *regparse != ']') {
-                               if (*regparse == '-') {
+                       if (GET_UCHAR(regparse) == ']' || GET_UCHAR(regparse) == '-')
+                         REGC(GET_UCHAR(regparse++));
+                       while (GET_UCHAR(regparse) != '\0' && GET_UCHAR(regparse) != ']') {
+                         if (GET_UCHAR(regparse) == '-') {
                                        regparse++;
-                                       if (*regparse == ']' || *regparse == '\0')
+                                       if (GET_UCHAR(regparse) == ']' || GET_UCHAR(regparse) == '\0')
                                                REGC('-');
                                        else {
-                                               clss = UCHARAT(regparse-2)+1;
-                                               classend = UCHARAT(regparse);
+                                               clss = GET_UCHAR(regparse-2)+1;
+                                               classend = GET_UCHAR(regparse);
                                                if (clss > classend+1)
                                                        FAIL("invalid [] range");
                                                for (; clss <= classend; clss++)
@@ -544,10 +551,10 @@ regatom(int *flagp)
                                                regparse++;
                                        }
                                } else
-                                       REGC(*regparse++);
+                           REGC(GET_UCHAR(regparse++));
                        }
                        REGC('\0');
-                       if (*regparse != ']')
+                       if (GET_UCHAR(regparse) != ']')
                                FAIL("unmatched []");
                        regparse++;
                        *flagp |= HASWIDTH|SIMPLE;
@@ -597,10 +604,10 @@ regatom(int *flagp)
                /* NOTREACHED */
                break;
        case '\\':
-               if (*regparse == '\0')
+         if (GET_UCHAR(regparse) == '\0')
                        FAIL("trailing \\");
                ret = regnode(EXACTLY);
-               regc(*regparse++);
+               regc(GET_UCHAR(regparse++));
                regc('\0');
                *flagp |= HASWIDTH|SIMPLE;
                break;
@@ -609,10 +616,12 @@ regatom(int *flagp)
                        register char ender;
 
                        regparse--;
-                       len = strcspn(regparse, META);
+                       len=({ufixnum _l=0;char _c,*_s=regparse;/*strcspn*/
+                           for (;(_c=GET_UCHAR(_s++)) && !strchr(META,_c);_l++);
+                           _l;});
                        if (len <= 0)
                                FAIL("internal disaster");
-                       ender = *(regparse+len);
+                       ender = GET_UCHAR(regparse+len);
                        if (len > 1 && ISMULT(ender))
                                len--;          /* Back off clear of ?+* operand. */
                        *flagp |= HASWIDTH;
@@ -620,7 +629,7 @@ regatom(int *flagp)
                                *flagp |= SIMPLE;
                        ret = regnode(EXACTLY);
                        while (len > 0) {
-                               regc(*regparse++);
+                         regc(GET_UCHAR(regparse++));
                                len--;
                        }
                        regc('\0');
@@ -775,7 +784,6 @@ static int
 regexec(register regexp *prog, register char *string, char *start, int length)
 {
        register char *s;
-       char saved,*savedp=NULL;
        int value;
 
        /* Be paranoid... */
@@ -806,13 +814,8 @@ regexec(register regexp *prog, register char *string, char *start, int length)
                        return(0);
        }
 
-       /* null terminate string */
-       if (length)
-         { savedp = &string[length];
-           saved = *savedp;
-           if (saved) *savedp=0;
-         }
-       else saved=0;
+       regend=string+length;
+
 #define RETURN_VAL(i) do {value=i; goto DO_RETURN;}while(0)
 
        /* Mark beginning of line for ^ . */
@@ -836,13 +839,13 @@ regexec(register regexp *prog, register char *string, char *start, int length)
 
            
            int amt;
-           unsigned char *s = (unsigned char *)string+ advance -1;
+           char *s = string+ advance -1;
            min_initial_branch_length(prog, buf,advance);
            switch(advance) {
            case 1:
              while (1)
-             { if (buf[*s]==0)
-                 { if (*s == 0) RETURN_VAL(0);
+               { if (buf[GET_UCHAR(s)]==0)
+                   { if (GET_UCHAR(s) == 0) RETURN_VAL(0);
                    else
                      if (regtry(prog,(char *)s-(1-1))) RETURN_VAL(1);}
                s++; }
@@ -851,10 +854,10 @@ regexec(register regexp *prog, register char *string, char *start, int length)
            case 2:
            while (length > 0)
              { 
-               amt = (buf[s[0]]);
+               amt = (buf[GET_UCHAR(s)]);
                if (amt == 0)
                  {
-                   amt = buf[s[-1]]-1;
+                   amt = buf[GET_UCHAR(s-1)]-1;
                    if (amt <=0) {
                      if (regtry(prog,(char *)s-(advance-1))) 
                        RETURN_VAL(1);
@@ -867,24 +870,24 @@ regexec(register regexp *prog, register char *string, char *start, int length)
            RETURN_VAL(0);
          case 3:
            while (length > 0)
-             { amt = (buf[s[0]]);
+             { amt = (buf[GET_UCHAR(s)]);
                if (amt == 0)
-                 {amt = buf[s[-1]]-1;
+                 {amt = buf[GET_UCHAR(s-1)]-1;
                   if (amt <=0)
-                    {amt = buf[s[-2]]-2;
+                    {amt = buf[GET_UCHAR(s-2)]-2;
                      if (amt <=0)
                        {if (regtry(prog,(char *)s-(advance-1))) RETURN_VAL(1);
                        else amt =1;}}}
                s += amt; length -= amt;}
          case 4:
            while (length > 0)
-             { amt = (buf[s[0]]);
+             { amt = (buf[GET_UCHAR(s)]);
                if (amt == 0)
-                 {amt = buf[s[-1]]-1;
+                 {amt = buf[GET_UCHAR(s-1)]-1;
                   if (amt <=0)
-                    {amt = buf[s[-2]]-2;
+                    {amt = buf[GET_UCHAR(s-2)]-2;
                      if (amt <=0)
-                       {amt = buf[s[-3]]-3;
+                       {amt = buf[GET_UCHAR(s-3)]-3;
                         if (amt <=0)
                           {if (regtry(prog,(char *)s-(advance-1))) RETURN_VAL(1);
                           else amt =1;}}}}
@@ -892,15 +895,15 @@ regexec(register regexp *prog, register char *string, char *start, int length)
 
          default:
            while (length > 0)
-             { amt = (buf[s[0]]);
+             { amt = (buf[GET_UCHAR(s)]);
                if (amt == 0)
-                 {amt = buf[s[-1]]-1;
+                 {amt = buf[GET_UCHAR(s-1)]-1;
                   if (amt <=0)
-                    {amt = buf[s[-2]]-2;
+                    {amt = buf[GET_UCHAR(s-2)]-2;
                      if (amt <=0)
-                       {amt = buf[s[-3]]-3;
+                       {amt = buf[GET_UCHAR(s-3)]-3;
                         if (amt <=0)
-                          {amt = buf[s[-4]]-4;
+                          {amt = buf[GET_UCHAR(s-4)]-4;
                            if (amt <=0)
                           {if (regtry(prog,(char *)s-(advance-1))) RETURN_VAL(1);
                           else amt =1;}}}}}
@@ -913,13 +916,13 @@ regexec(register regexp *prog, register char *string, char *start, int length)
                /* We know what char it must start with. */
          { if (case_fold_search)
              {char ch = tolower(prog->regstart);
-              while (*s)
-                { if (tolower(*s)==ch)
+               while (GET_UCHAR(s))
+                 { if (tolower((GET_UCHAR(s)))==ch)
                     {if (regtry(prog, s))
                        RETURN_VAL(1);}
                   s++;}}
            else
-             while ((s = strchr(s, prog->regstart)) != NULL) {
+             while ((s = memchr(s, prog->regstart,regend-s)) != NULL) {
                if (regtry(prog, s))
                  RETURN_VAL(1);
                s++;
@@ -930,12 +933,11 @@ regexec(register regexp *prog, register char *string, char *start, int length)
                do {
                        if (regtry(prog, s))
                                RETURN_VAL(1);
-               } while (*s++ != '\0');
+               } while (GET_UCHAR(s) && s++);
 
        /* Failure. */
        RETURN_VAL(0);
       DO_RETURN:
-       if(saved) *savedp=saved;
        return value;
        
 }
@@ -1040,11 +1042,11 @@ regmatch(char *prog)
                                return(0);
                        break;
                case EOL:
-                       if (*reginput != '\0')
+                 if (GET_UCHAR(reginput) != '\0')
                                return(0);
                        break;
                case ANY:
-                       if (*reginput == '\0')
+                 if (GET_UCHAR(reginput) == '\0')
                                return(0);
                        reginput++;
                        break;
@@ -1055,12 +1057,12 @@ regmatch(char *prog)
                                opnd = OPERAND(scan);
                                if (case_fold_search)
                                while (*opnd )
-                                 { if (tolower(*opnd) != tolower(*ch))
+                                 { if (tolower(*opnd) != tolower(GET_UCHAR(ch)))
                                       return 0;
                                    else { ch++; opnd++;}}
                                else
                                while (*opnd )
-                                 { if (*opnd != *ch)
+                                 { if (*opnd != GET_UCHAR(ch))
                                       return 0;
                                    else { ch++; opnd++;}}
                                /* a match */
@@ -1068,14 +1070,14 @@ regmatch(char *prog)
                        }
                        break;
                case ANYOF:
-                       if (*reginput == '\0' ||
-                           OPERAND(scan)[*(unsigned char *)reginput] == 0)
+                 if (GET_UCHAR(reginput) == '\0' ||
+                     OPERAND(scan)[GET_UCHAR(reginput)] == 0)
                                return(0);
                        reginput++;
                        break;
                case ANYBUT:
-                       if (*reginput == '\0' ||
-                           OPERAND(scan)[*(unsigned char *)reginput] != 0)
+                 if (GET_UCHAR(reginput) == '\0' ||
+                     OPERAND(scan)[GET_UCHAR(reginput)] != 0)
                                return(0);
                        reginput++;
                        break;
@@ -1168,9 +1170,9 @@ regmatch(char *prog)
                                while (no >= min) {
                                        /* If it could work, try it. */
                                        if (nextch == '\0' ||
-                                           *reginput == nextch
+                                           GET_UCHAR(reginput) == nextch
                                            || (case_fold_search &&
-                                             tolower(*reginput) == nextch))
+                                               tolower(GET_UCHAR(reginput)) == nextch))
                                                if (regmatch(next))
                                                        return(1);
                                        /* Couldn't or didn't -- back up. */
@@ -1217,34 +1219,34 @@ regrepeat(char *p)
        opnd = OPERAND(p);
        switch (OP(p)) {
        case ANY:
-               count = strlen(scan);
+               count = regend-scan/* strlen(scan) */;
                scan += count;
                break;
        case EXACTLY:
                { char ch = *opnd;
                if (case_fold_search)
                  { ch = tolower(*opnd);
-                   while (ch == tolower(*scan))
+                   while (ch == tolower(GET_UCHAR(scan)))
                      {
                        count++;
                        scan++;}}
                else
-                 while (ch  == *scan) {
+                 while (ch  == GET_UCHAR(scan)) {
                    count++;
                    scan++;
                }}
                break;
        case ANYOF:
-               while (*scan != '\0' &&
-                      opnd[*(unsigned char *)scan] != 0)
+         while (GET_UCHAR(scan) != '\0' &&
+                opnd[GET_UCHAR(scan)] != 0)
                  {
                        count++;
                        scan++;
                }
                break;
        case ANYBUT:
-               while (*scan != '\0' &&
-                      opnd[*(unsigned char *)scan] == 0)
+         while (GET_UCHAR(scan) != '\0' &&
+                opnd[GET_UCHAR(scan)] == 0)
          {
                        count++;
                        scan++;

diff --git a/o/regexpr.c b/o/regexpr.c
index 359a8aaf06a8106ddbb265599c34d70bbd576a11..c1915037a6b39fe7a5adf5c30ebcea209f7f1cf9 100644 (file)
--- a/o/regexpr.c
+++ b/o/regexpr.c
@@ -65,18 +65,13 @@ DEFUN("MATCH-END",object,fSmatch_end,SI,1,1,NONE,OI,OO,OO,OO,(fixnum i),
 DEFUN("COMPILE-REGEXP",object,fScompile_regexp,SI,1,1,NONE,OO,OO,OO,OO,(object p),
          "Provide handle to export pre-compiled regexp's to string-match") {
 
-  char *tmp;
   object res;
   void *v;
   ufixnum sz=0;
 
   p=coerce_to_string(p);
-  if (!(tmp=alloca(VLEN(p)+1)))
-    FEerror("out of C stack",0);
-  memcpy(tmp,p->st.st_self,VLEN(p));
-  tmp[VLEN(p)]=0;
 
-  if (!(v=(void *)regcomp(tmp,&sz)))
+  if (!(v=(void *)regcomp(p->st.st_self,&sz,VLEN(p))))
     FEerror("regcomp failure",0);
 
   res=alloc_object(t_vector);
@@ -115,7 +110,7 @@ be over written.   \
   int len,start,end;
   va_list ap;
   object v=sSAmatch_dataA->s.s_dbind,l=Cnil,f=OBJNULL;
-  char **pp,*str,save_c=0;
+  char **pp,*str;
 
   if (!stringp(pattern) && type_of(pattern)!=t_symbol &&
       (type_of(pattern)!=t_vector || pattern->v.v_elttype!=aet_uchar))
@@ -168,20 +163,8 @@ be over written.   \
     }
 
     str=string->st.st_self;
-    if (NULL_OR_ON_C_STACK(str+end) || str+end==(void *)compiled_regexp) {
-
-      if (!(str=alloca(VLEN(string)+1)))
-       FEerror("Cannot allocate memory on C stack",0);
-      memcpy(str,string->st.st_self,VLEN(string));
-
-    } else
-      save_c=str[end];
-    str[end]=0;
-
     ans = regexec(compiled_regexp,str+start,str,end-start);
 
-    str[end] = save_c;
-
     if (!ans ) {
       END_NO_INTERRUPT;
       RETURN1((object)-1);

diff --git a/o/sfasli.c b/o/sfasli.c
index cbd848290542d96d1ebe57155ec1b67faf9814ca..6e824e722b4691fcd7444584a57829e091f0a88b 100644 (file)
--- a/o/sfasli.c
+++ b/o/sfasli.c
@@ -157,7 +157,7 @@ use_symbols(double d,...) {
     d=d/(c+I*d);
   }
 
-#if defined(__APPLE__) && defined(__aarch64__)/*FIXME non-lazy pointer support in sfaslmacho.c*/
+#if defined(__APPLE__)/*FIXME non-lazy pointer support in sfaslmacho.c*/
   extern  void __chkstk_darwin(void);
   __chkstk_darwin();
 #endif

diff --git a/o/sfaslmacho.c b/o/sfaslmacho.c
index fee911273041bad574d51abba2e54443683cca4e..48499c73748dffb98827c4c507d5bceebff1a534 100644 (file)
--- a/o/sfaslmacho.c
+++ b/o/sfaslmacho.c
@@ -48,7 +48,7 @@ typedef unsigned long ul;
 STATIC_RELOC_VARS
 #endif
 
-static int
+static inline int
 ovchks(ul v,ul m) {
 
   m|=m>>1;
@@ -58,14 +58,14 @@ ovchks(ul v,ul m) {
 
 }
 
-static int
+static inline int
 ovchku(ul v,ul m) {
 
   return !(v&=m);
 
 }
 
-static int
+static inline int
 store_val(ul *w,ul m,ul v) {
 
   *w=(v&m)|(*w&~m);
@@ -74,7 +74,7 @@ store_val(ul *w,ul m,ul v) {
 
 }
 
-static int
+static inline int
 store_valu(ul *w,ul m,ul v) {
 
   massert(ovchku(v,~m));
@@ -84,7 +84,7 @@ store_valu(ul *w,ul m,ul v) {
 
 }
 
-static int
+static inline int
 store_vals(ul *w,ul m,ul v) {
 
   massert(ovchks(v,~m));
@@ -92,21 +92,19 @@ store_vals(ul *w,ul m,ul v) {
 
 }
 
-#ifdef W_X
-static int
+static inline int
 add_vals(ul *w,ul m,ul v) {
 
-  return store_vals(w,m,v+(*w&m));
+  return store_vals(w,m,v+(*w&m)-((*w&((m+1)>>1))<<1));
 
 }
 
-static int
+static inline int
 add_valu(ul *w,ul m,ul v) {
 
   return store_valu(w,m,v+(*w&m));
 
 }
-#endif
 
 #ifndef _LP64
 /*redirect trampolines gcc-4.0 gives no reloc for stub sections on x86 only*/
@@ -467,12 +465,10 @@ dup_sym(char *src) {
   if ((c=strstr(src,e))) {
     memcpy(buf,src,(c-src));
     buf[c-src]=0;
-    printf("dup %s -> %s\n",src,buf);
     return buf;
   }
   if (!strcmp(src,"_my_free")||!strcmp(src,"_my_calloc")||!strcmp(src,"_my_malloc")||!strcmp(src,"_my_realloc")) {
     strcpy(buf,src+3);
-    printf("dup %s -> %s\n",src,buf);
     return buf;
   }
   return NULL;

diff --git a/o/unexmacosx.c b/o/unexmacosx.c
index 1c976a5f899ae303f1a1bc5fbebeed4ce31e39e4..972eb8bc1dd083357366f56afd7be1f415d95037 100644 (file)
--- a/o/unexmacosx.c
+++ b/o/unexmacosx.c
@@ -864,6 +864,7 @@ typedef struct {
 typedef struct {
   uint32_t magic;      /* 0xfade0b01 (CSMAGIC_BLOBWRAPPER) */
   uint32_t length;     /* Total length of header + CMS data */
+  uint8_t zero[18040-30];
 } CS_BlobWrapper;
 
 #include <CommonCrypto/CommonDigest.h>
@@ -893,7 +894,7 @@ dump_code_signature(struct segment_command *le_seg,
   CS_Requirements rq;
   CS_BlobWrapper cms;
   const char *id="GCL";
-  const long nss=2,ss=32,id_len=RNDUP(strlen(id)+1,8);
+  const long nss=2,ss=32,id_len=strlen(id)+1;
   long cd_len,len,np,i;
   uint8_t hash[32],data[PAGESIZE];
   void *v;
@@ -901,11 +902,6 @@ dump_code_signature(struct segment_command *le_seg,
 
   lseek(outfd,0,SEEK_END);
   len=lseek(outfd,0,SEEK_CUR);
-  if (len%16) {
-    unsigned long x=0;
-    mwrite(&x,sizeof(x));
-    len=lseek(outfd,0,SEEK_CUR);
-  }
   ldc.dataoff=len;
 
   np=RNDUP(len,PAGESIZE)>>PAGEWIDTH;
@@ -916,7 +912,7 @@ dump_code_signature(struct segment_command *le_seg,
   curr_header_offset+=ldc.cmdsize;
 
   le_seg->filesize+=ldc.datasize;
-  le_seg->vmsize+=RNDUP(ldc.datasize,PAGESIZE);
+  le_seg->vmsize+=RNDUP(ldc.datasize,1<<14);
   mpwrite(le_seg,sizeof(*le_seg),le_ho);
 
   uassert(curr_header_offset<=text_seg_lowest_offset);
@@ -931,7 +927,7 @@ dump_code_signature(struct segment_command *le_seg,
   mpwrite(&mh,sizeof(mh),0);
 
   sb.magic=htonl(0xfade0cc0);
-  sb.length=htonl(sizeof(sb)+sizeof(bi)+cd_len+sizeof(rq)+sizeof(cms));
+  sb.length=htonl(ldc.datasize-sizeof(cms.zero)-2);
   sb.count=htonl(sizeof(bi)/sizeof(*bi));
   mwrite(&sb,sizeof(sb));
 
@@ -972,7 +968,7 @@ dump_code_signature(struct segment_command *le_seg,
   mwrite(v,id_len);
 
   rq.magic=htonl(0xfade0c01);
-  rq.length=htonl(12);
+  rq.length=htonl(sizeof(rq));
   rq.count=htonl(0);
   CC_SHA256(&rq,sizeof(rq),hash);
   mwrite(hash,sizeof(hash));
@@ -981,9 +977,9 @@ dump_code_signature(struct segment_command *le_seg,
   mwrite(hash,sizeof(hash));
 
   for (i=0;i<np;i++) {
-    uassert(memset(data,0,sizeof(data)));
-    mpred(data,i==np-1 ? ntohl(cd.codeLimit)-(i<<PAGEWIDTH) : sizeof(data),i<<PAGEWIDTH);
-    CC_SHA256(data,sizeof(data),hash);
+    unsigned long n=i==np-1 ? ntohl(cd.codeLimit)-(i<<PAGEWIDTH) : sizeof(data);
+    mpred(data,n,i<<PAGEWIDTH);
+    CC_SHA256(data,n,hash);
     mwrite(hash,sizeof(hash));
   }
 
@@ -1006,6 +1002,9 @@ dump_it () {
   long linkedit_delta=0,linkedit_vmdelta=0,linkedit_vmsize=0,text_vmaddr=0;
   struct segment_command *le_seg=NULL,*tx_seg=NULL;
   unsigned long le_ho=0;
+  extern unsigned long heap_vmsize;
+  extern int in_pre_gcl;/*support libboot.so*/
+  extern char *data_start;
   
 #if VERBOSE
   printf ("--- Load Commands written to Output File ---\n");
@@ -1023,6 +1022,12 @@ dump_it () {
       }
     }
   uassert(le_seg&&tx_seg);
+  {
+    heap_vmsize=                                                       \
+      (in_pre_gcl ? SAVED_PRE_IMAGE_SPAN : SAVED_IMAGE_SPAN) -         \
+      (long)((long)data_start-text_vmaddr) -                           \
+      linkedit_vmsize;
+  }
   
   for (i = 0; i < nlc; i++)
     switch (lca[i]->cmd) {
@@ -1049,10 +1054,6 @@ dump_it () {
          struct section *sectp = (struct section *) (scp + 1);
          unsigned long header_offset=curr_header_offset + sizeof (struct segment_command);
          extern int in_pre_gcl;/*support libboot.so*/
-         unsigned long heap_vmsize=                                    \
-           (in_pre_gcl ? SAVED_PRE_IMAGE_SPAN : SAVED_IMAGE_SPAN) -    \
-           (long)((long)data_start-text_vmaddr) -                      \
-           linkedit_vmsize;
 
          if (core_end-data_start>heap_vmsize)
            unexec_error ("data exceeds __HEAP vmsize");